S01-05 JavaSE-基础-流程控制语句

[TOC]

程序流程控制介绍

在程序中，程序运行的流程控制决定程序是如何执行的，是我们必须掌握的，主要有三大流程控制语句。

顺序控制
分支控制
循环控制

顺序控制

程序从上到下逐行地执行，中间没有任何判断和跳转。

顺序控制举例和注意事项

Java中定义变量时采用合法的前向引用。如：

java

public class Test{
int num1 = 12;
int num2 = num1 + 2;
}

错误形式：

java

public class Test{
int num2= num1+2;//错误
int num1=12;
}

分支控制if-else

分支控制if-else 介绍

让程序有选择的执行，分支控制有三种：

单分支if
双分支if-else
多分支if-else if -....-else

单分支

基本语法：

java

if(条件表达式){
执行代码块;(可以有多条语句。)
}

说明：当条件表达式为true时，就会执行{}的代码。如果为false，就不执行。特别说明，如果{}中只有一条语句，则可以不用{}，韩老师建议写上{}。

案例说明

(If01.java)：编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出"你年龄大于18，要对自己的行为负责，送入监狱"

java

//if 的快速入门
import java.util.Scanner;//导入
public class If01 {
//编写一个main 方法
public static void main(String[] args) {
//思路分析
//1. 接收输入的年龄，应该定义一个Scanner对象
//2. 把年龄保存到一个变量int age
//3. 使用if 判断，输出对应信息
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入年龄");
int age = myScanner.nextInt();
System.out.println("程序继续...");
//使用if 判断，输出对应信息
if(age > 18) {
System.out.println("你年龄大于18，要对自己的行为负责，送入监狱");
}
}
}

单分支流程图

条件表达式 -> true -> 执行代码块
          -> false -> 不执行

双分支

基本语法

java

if(条件表达式){
执行代码块1;
}else{
执行代码块2;
}

说明：当条件表达式成立，即执行代码块1，否则执行代码块2。如果执行代码块只有一条语句，则{}可以省略，否则，不能省略。

案例演示

(If02.java)：编写一个程序，可以输入人的年龄，如果该同志的年龄大于18岁，则输出"你年龄大于18，要对自己的行为负责送入监狱"。否则，输出"你的年龄不大这次放过你了"

java

//if-else 的快速入门
import java.util.Scanner;//导入
public class If02 {
//编写一个main 方法
public static void main(String[] args) {
//思路分析
//1. 接收输入的年龄，应该定义一个Scanner对象
//2. 把年龄保存到一个变量int age
//3. 使用if-else 判断，输出对应信息
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入年龄");
int age = myScanner.nextInt();
//使用if-else 判断，输出对应信息
if(age > 18) {
System.out.println("你年龄大于18，要对自己的行为负责，送入监狱");
} else {
System.out.println("你的年龄不大这次放过你了");
}
System.out.println("程序继续...");
}
}

双分支流程图

条件表达式 -> true -> 执行代码块1 -> 继续...
          -> false -> 执行代码块2 -> 继续...

单分支和双分支练习题

对下列代码，若有输出，指出输出结果。

java

int x=7;
int y=4;
if (x>5){
if (y >5){
System.out.println(x + y);
}
} else
System.out.println("x is " + x);
System.out.println("韩顺平教育~");
//输出的内容是韩顺平教育~

(IfExercise01.java)
1. 编写程序，声明2个double型变量并赋值。判断第一个数大于10.0，且第2个数小于20.0，打印两数之和。
2. 【课后自己练】定义两个变量int，判断二者的和，是否能被3又能被5整除，打印提示信息。
3. 判断一个年份是否是闰年，闰年的条件是符合下面二者之一：(1)年份能被4整除，但不能被100整除；(2)能被400整除。

java

//单分支和双分支的练习
public class IfExercise01 {
//编写一个main 方法
public static void main(String[] args) {
//1) 编写程序，声明2个double型变量并赋值。
//判断第一个数大于10.0，且第2个数小于20.0，打印两数之和
double d1 = 33.5;
double d2 = 2.6;
if(d1 > 10.0 && d2 < 20.0) {
System.out.println("两个数和=" + (d1 + d2));
}

//2) 【课后自己练】定义两个变量int，判断二者的和，是否能被3又能被5整除，打印提示信息
int num1 = 10;
int num2 = 1;
int sum = num1 + num2;
if(sum % 3 == 0 && sum % 5 == 0) {
System.out.println("和可以被3 又能被5 整除");
} else {
System.out.println("和不能被3 和5 整除..");
}

//3) 判断一个年份是否是闰年
int year = 2028;
if( (year % 4 == 0 && year % 100 != 0) || year % 400 == 0 ) {
System.out.println(year + " 是闰年");
} else {
System.out.println(year + " 不是闰年");
}
}
}

多分支

基本语法

java

if(条件表达式1){
执行代码块1;
}else if(条件表达式2){
执行代码块2;
...
}else{
执行代码块n;
}

特别说明：

多分支可以没有else，如果所有的条件表达式都不成立，则一个执行入口都没有
如果有else，如果所有的条件表达式都不成立，则默认执行else代码块

多分支的流程图(重要!)

条件表达式1 -> true -> 执行代码块1 -> 结束
          -> false -> 条件表达式2 -> true -> 执行代码块2 -> 结束
                              -> false -> ... -> 条件表达式n -> true -> 执行代码块n -> 结束
                                                               -> false -> 执行代码块n(else) -> 结束

说明：

当条件表达式1成立时，即执行代码块1
如果表达式1不成立，才去判断表达式2是否成立
如果表达式2成立，就执行代码块2
以此类推，如果所有的表达式都不成立
则执行else的代码块，注意，只能有一个执行入口。

案例演示1

(If03.java)：输入保国同志的芝麻信用分：如果：

信用分为100分时，输出信用极好；
信用分为(80,99]时，输出信用优秀；
信用分为[60,80]时，输出信用一般；
其它情况，输出信用不及格
请从键盘输入保国的芝麻信用分，并加以判断

java

//课堂练习
import java.util.Scanner;
public class If03 {
//编写一个main 方法
public static void main(String[] args) {
/*
输入保国同志的芝麻信用分：
如果：
信用分为100分时，输出信用极好；
信用分为(80,99]时，输出信用优秀；
信用分为[60,80]时，输出信用一般；
其它情况，输出信用不及格
请从键盘输入保国的芝麻信用分，并加以判断
假定信用分数为int
*/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入信用分(1-100):");
int grade = myScanner.nextInt();
//先对输入的信用分，进行一个范围的有效判断1-100，否则提示输入错误
if(grade >=1 && grade <= 100) {
//因为有4种情况，所以使用多分支
if(grade == 100) {
System.out.println("信用极好");
} else if (grade > 80 && grade <= 99) {
//信用分为(80,99]时，输出信用优秀；
System.out.println("信用优秀");
} else if (grade >= 60 && grade <= 80) {
//信用分为[60,80]时，输出信用一般
System.out.println("信用一般");
} else {
//其它情况，输出信用不及格
System.out.println("信用不及格");
}
} else {
System.out.println("信用分需要在1-100，请重新输入:)");
}
}
}

案例演示2

java

//代码，看看输出什么?
boolean b = true;
if(b=false) {
System.out.println("a");
} else if(!b) {
System.out.println("b");
} else {
System.out.println("c");
}
System.out.println("d");

嵌套分支

基本介绍

在一个分支结构中又完整的嵌套了另一个完整的分支结构，里面的分支的结构称为内层分支，外面的分支结构称为外层分支。老师建议：不要超过3层(可读性不好)

基本语法

java

if(){
//外层分支
if() {
//内层分支
//if-else....
}
}else{
//if-else....
}

应用案例

参加歌手比赛，如果初赛成绩大于8.0进入决赛，否则提示淘汰。并且根据性别提示进入男子组或女子组。【可以让学员先练习下】，输入成绩和性别，进行判断和输出信息。[NestedIf.java] 提示：double score; char gender; 接收字符：char gender = scanner.next().charAt(0)

java

import java.util.Scanner;
public class NestedIf {
//编写一个main 方法
public static void main(String[] args) {
/*
参加歌手比赛，如果初赛成绩大于8.0
进入决赛，输入成绩和性别，进行判断和输出信息。
否则提示淘汰。并且根据性别提示进入男子组或女子组。
[NestedIf.java]
提示: double score; char gender;
*/
//思路分析
//1. 创建Scanner 对象，接收用户输入
//2. 接收成绩保存到double score
//3. 使用if-else 判断如果初赛成绩大于8.0 进入决赛，否则提示淘汰
//4. 如果进入到决赛，再接收char gender，使用if-else 输出信息
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入该歌手的成绩");
double score = myScanner.nextDouble();
if( score > 8.0 ) {
System.out.println("请输入性别");
char gender = myScanner.next().charAt(0);
if( gender == '男' ) {
System.out.println("进入男子组");
} else if(gender == '女') {
System.out.println("进入女子组");
} else {
System.out.println("你的性别有误，不能参加决赛~");
}
} else {
System.out.println("sorry，你被淘汰了");
}
}
}

应用案例2，一定自己做

出票系统：根据淡旺季的月份和年龄，打印票价[课后练习] 4-10旺季：成人(18-60)：60；儿童(<18)：半价；老人(>60)：1/3 淡季：成人：40；其他：20 思路分析：(1)淡旺季-if-else(2)在旺季中，可以使用多分支处理三种情况(3)在淡季情况，使用双分支处理即可

switch 分支结构

基本语法

java

switch(表达式){
case 常量1:
//当表达式的值等于常量1，执行语句块1
语句块1;
break;
case 常量2:
语句块2;
break;
...
case 常量n:
语句块n;
break;
default:
default语句块;
break;
}

老韩解读switch：

switch关键字，表示switch分支
表达式对应一个值
case常量1：当表达式的值等于常量1，就执行语句块1
break：表示退出switch
如果和case常量1匹配，就执行语句块1，如果没有匹配，就继续匹配case常量2
如果一个都没有匹配上，执行default

流程图

计算表达式的值 -> 等于常量1? -> true -> 执行语句块1 -> 有break? -> 是 -> 结束switch
                          -> false -> 等于常量2? -> true -> 执行语句块2 -> 有break? -> 是 -> 结束switch
                                      -> false -> ... -> 等于常量n? -> true -> 执行语句块n -> 有break? -> 是 -> 结束switch
                                                                      -> false -> 执行default语句 -> 有break? -> 是 -> 结束switch

快速入门

案例：Switch01.java 请编写一个程序，该程序可以接收一个字符，比如：a,b,c,d,e,f,g a表示星期一，b表示星期二… 根据用户的输入显示相应的信息。要求使用switch语句完成

java

import java.util.Scanner;
public class Switch01 {
//编写一个main 方法
public static void main(String[] args) {
/*
案例:Switch01.java
请编写一个程序，该程序可以接收一个字符，比如:a,b,c,d,e,f,g
a表示星期一,b表示星期二...
根据用户的输入显示相应的信息.要求使用switch 语句完成
思路分析
1. 接收一个字符，创建Scanner 对象
2. 使用switch 来完成匹配，并输出对应信息
*/
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入一个字符(a-g)");
char c1 = myScanner.next().charAt(0);//接收字符
switch(c1) {
case 'a' :
System.out.println("今天星期一，猴子穿新衣");
break;
case 'b' :
System.out.println("今天星期二，猴子当小二");
break;
case 'c' :
System.out.println("今天星期三，猴子爬雪山..");
break;
//.....其他case省略
default:
System.out.println("你输入的字符不正确，没有匹配的");
break;
}
System.out.println("退出了switch，继续执行程序");
}
}

switch 注意事项和细节讨论

(SwitchDetail.java)

表达式数据类型，应和case后的常量类型一致，或者是可以自动转成可以相互比较的类型，比如输入的是字符，而常量是int
switch(表达式)中表达式的返回值必须是：(byte,short,int,char,enum[枚举],String)
java
```
double c=1.1;
switch(c){//错误
case 1.1://错误
System.out.println("ok3");
break;
}
```
1
2
3
4
5
6
case子句中的值必须是常量，而不能是变量
default子句是可选的，当没有匹配的case时，执行default
break语句用来在执行完一个case分支后使程序跳出switch语句块；如果没有写break，会发生穿透现象

switch 课堂练习(学员先做)

(SwitchExercise.java)

使用switch把小写类型的char型转为大写(键盘输入)。只转换a,b,c,d,e.其它的输出"other"。
对学生成绩大于60分的，输出"合格"。低于60分的，输出"不合格"。(注：输入的成绩不能大于100)，提示成绩/60
根据用于指定月份，打印该月份所属的季节。3,4,5春季；6,7,8夏季；9,10,11秋季；12,1,2冬季[课堂练习，提示使用穿透]

java

import java.util.Scanner;
public class SwitchExercise {
//编写一个main 方法
public static void main(String[] args) {
//1) 使用switch 把小写类型的char 型转为大写(键盘输入)。只转换a->A, b->B, c->C, d->D, e->E. 其它的输出"other"。
Scanner myScanner = new Scanner(System.in);
System.out.println("请输入a-e");
char c1 = myScanner.next().charAt(0);
switch(c1) {
case 'a' :
System.out.println("A");
break;
case 'b' :
System.out.println("B");
break;
case 'c' :
System.out.println("C");
break;
case 'd' :
System.out.println("D");
break;
case 'e' :
System.out.println("E");
break;
default :
System.out.println("other");
break;
}

//2) 对学生成绩大于60分的，输出"合格"。低于60分的，输出"不合格"。(注：输入的成绩不能大于100)
double score = 1.1;
if( score >= 0 && score <= 100) {
switch ((int)(score / 60)) {
case 0 :
System.out.println("不合格");
break;
case 1 :
System.out.println("合格");
break;
}
} else {
System.out.println("输入的成绩在0-100");
}

//3) 根据用于指定月份，打印该月份所属的季节。
System.out.println("输入月份");
int month = myScanner.nextInt();
switch(month) {
case 3:
case 4:
case 5:
System.out.println("这是春季");
break;
case 6:
case 7:
case 8:
System.out.println("这是夏季");
break;
case 9:
case 10:
case 11:
System.out.println("这是秋季");
break;
case 1:
case 2:
case 12:
System.out.println("这是冬季");
break;
default :
System.out.println("你输入的月份不对(1-12)");
break;
}
}
}

switch 和if 的比较

如果判断的具体数值不多，而且符合byte、short、int、char、enum[枚举]、String这6种类型。虽然两个语句都可以使用，建议使用switch语句。
其他情况：对区间判断，对结果为boolean类型判断，使用if，if的使用范围更广

for 循环控制(!!!)

基本介绍

听其名而知其意，就是让你的代码可以循环的执行。

看一个实际需求

请大家看个案例[For01.java]：编写一个程序，可以打印10句"你好，韩顺平教育!"。请大家想想怎么做？

基本语法

java

for(循环变量初始化;循环条件;循环变量迭代){
循环操作(可以多条语句);
}

老韩说明：

for关键字，表示循环控制
for有四要素：(1)循环变量初始化(2)循环条件(3)循环操作(4)循环变量迭代
循环操作，这里可以有多条语句，也就是我们要循环执行的代码
如果循环操作(语句)只有一条语句，可以省略{}，建议不要省略

for 循环执行流程分析

使用for循环完成前面的题
画出for流程图

循环变量初始化 -> 循环条件 -> true -> 循环操作 -> 循环变量迭代 -> 循环条件
                          -> false -> for循环结束

代码执行，内存分析法(初学者)图

java

//使用for循环控制
for( int i=1; i<=10; i++){
System.out.println("你好，韩顺平教育" + i);
}

注意事项和细节说明

(ForDetail.java)

循环条件是返回一个布尔值的表达式
for(;循环判断条件;)中的初始化和变量迭代可以写到其它地方，但是两边的分号不能省略。
循环初始值可以有多条初始化语句，但要求类型一样，并且中间用逗号隔开，循环变量迭代也可以有多条变量迭代语句，中间用逗号隔开。
使用内存分析法，老师分析输出下面代码输出什么？

java

for (int i=0,j=0; i<3; i++,j+=2){
System.out.println("i=" + i + " j=" + j);
}

for 循环练习题(学员先做)

(ForExercise.java)

打印1~100之间所有是9的倍数的整数，统计个数及总和。[化繁为简，先死后活]

java

public class ForExercise {
//编写一个main 方法
public static void main(String[] args) {
//打印1~100 之间所有是9 的倍数的整数，统计个数及总和。[化繁为简，先死后活]
//老韩的两个编程思想(技巧)
//1. 化繁为简：即将复杂的需求，拆解成简单的需求，逐步完成 编程= 思想--练习-> 代码
//2. 先死后活：先考虑固定的值，然后转成可以灵活变化的值

//思路分析
//(1) 完成输出1-100 的值
//(2) 在输出的过程中，进行过滤，只输出9 的倍数 i % 9 ==0
//(3) 统计个数定义一个变量int count = 0; 当条件满足时count++;
//(4) 总和，定义一个变量int sum = 0; 当条件满足时累积sum += i;

//先死后活
//(1) 为了适应更好的需求，把范围的开始的值和结束的值，做出变量
int start = 1;
int end = 100;
int t = 9; // 倍数
int count = 0; //统计9 的倍数个数变量
int sum = 0; //总和
for(int i = start; i <= end; i++) {
if( i % t == 0) {
System.out.println("i=" + i);
count++;
sum += i;//累积
}
}
System.out.println("count=" + count);
System.out.println("sum=" + sum);
}
}

完成下面的表达式输出 [老师评讲ForExercise02.java]

0+5=5
1+4=5
2+3=5
3+2=5
4+1=5
5+0=5

java

public class ForExercise02 {
//编写一个main 方法
public static void main(String[] args) {
//化繁为简
//先死后活
int n = 5;
for( int i = 0; i <= n; i++) {
System.out.println(i + "+" + (n-i) + "=" + n);
}
}
}

while 循环控制

基本语法

java

循环变量初始化;
while(循环条件){
循环体(语句);
循环变量迭代;
}

老韩说明：

while循环也有四要素
只是四要素放的位置和for不一样

while 循环执行流程分析

(While01.java)

画出流程图

循环变量初始化 -> 循环条件 -> true -> 循环体 -> 循环变量迭代 -> 循环条件
                          -> false -> while结束

使用while循环完成前面的题

java

//while 循环的案例
public class While01 {
//编写一个main 方法
public static void main(String[] args) {
//输出10 句你好，韩顺平教育
int i = 1; //循环变量初始化
while( i <= 10 ) {//循环条件
System.out.println("你好，韩顺平教育" + i);//执行语句
i++;//循环变量迭代
}
System.out.println("退出while，继续..");
}
}

注意事项和细节说明

循环条件是返回一个布尔值的表达式
while循环是先判断再执行语句

课堂练习题[学员先做]

(WhileExercise.java)

打印1-100之间所有能被3整除的数[使用while，老师评讲]
打印40-200之间所有的偶数[使用while，课后练习]

java

public class WhileExercise {
//编写一个main 方法
public static void main(String[] args) {
// 打印1-100 之间所有能被3 整除的数[使用while，老师评讲]
// 化繁为简，先死后活
int i = 1;
int endNum = 100;
while( i <= endNum) {
if( i % 3 == 0) {
System.out.println("i=" + i);
}
i++;//变量自增
}

// 打印40-200 之间所有的偶数[使用while，课后练习]
System.out.println("========");
int j = 40; //变量初始化
while ( j <= 200) {
//判断
if( j % 2 == 0) {
System.out.println("j=" + j);
}
j++;//循环变量的迭代
}
}
}

do..while 循环控制

基本语法

java

循环变量初始化;
do{
循环体(语句);
循环变量迭代;
}while(循环条件);

老韩说明

do while 是关键字
也有循环四要素，只是位置不一样
先执行，再判断，也就是说，一定会至少执行一次
最后有一个分号;

do...while 循环执行流程分析

(DoWhile01.java)

画出流程图

循环变量初始化 -> 循环体 -> 循环变量迭代 -> 循环条件 -> true -> 循环体
                                                  -> false -> 退出do-while

使用do...while循环完成前面的题

java

//do-while循环的案例
public class DoWhile01 {
//编写一个main方法
public static void main(String[] args){
//输出10句你好，韩顺平教育
int i=1;//循环变量初始化
do{
System.out.println("你好，韩顺平教育" + i); //循环执行语句
i++;//循环变量迭代
}while(i <= 10);
System.out.println("退出do..while继续执行..");
}
}

注意事项和细节说明

循环条件是返回一个布尔值的表达式
do..while循环是先执行，再判断，因此它至少执行一次

课堂练习题【学员先做】

打印1-100 [学生做]
计算1-100的和[学生做]
统计1---200之间能被5整除但不能被3整除的个数(DoWhileExercise01.java)

java

public class DoWhileExercise01 {
//编写一个main 方法
public static void main(String[] args) {
//统计1---200 之间能被5 整除但不能被3 整除的个数
//化繁为简
//(1) 使用do-while 输出1-200
//(2) 过滤能被5 整除但不能被3 整除的数
//(3) 统计满足条件的个数int count = 0;
//先死后活
//(1) 范围的值1-200 你可以做出变量
int i = 1;
int count = 0; //统计满足条件的个数
do {
if( i % 5 == 0 && i % 3 != 0 ) {
System.out.println("i=" + i);
count++;
}
i++;
}while(i <= 200);
System.out.println("count=" + count);
}
}

如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止[System.out.println("老韩问:还钱吗?y/n")] do...while .. (DoWhileExercise02.java)

java

import java.util.Scanner;
public class DoWhileExercise02 {
//编写一个main 方法
public static void main(String[] args) {
//如果李三不还钱，则老韩将一直使出五连鞭，直到李三说还钱为止
//[System.out.println("老韩问:还钱吗?y/n")] do...while ..
//化繁为简
//(1) 不停的问还钱吗?
//(2) 使用char answer 接收回答，定义一个Scanner 对象
//(3) 在do-while 的while 判断如果是y 就不在循环
Scanner myScanner = new Scanner(System.in);
char answer = ' ';
do {
System.out.println("老韩使出五连鞭~");
System.out.println("老韩问:还钱吗?y/n");
answer = myScanner.next().charAt(0);
System.out.println("他的回答是" + answer);
}while(answer != 'y');//判断条件很关键
System.out.println("李三还钱了");
}
}

多重循环控制(难点! 重点!)

介绍

将一个循环放在另一个循环体内，就形成了嵌套循环。其中，for、while、do…while均可以作为外层循环和内层循环。【建议一般使用两层，最多不要超过3层，否则，代码的可读性很差】
实质上，嵌套循环就是把内层循环当成外层循环的循环体。当只有内层循环的循环条件为false时，才会完全跳出内层循环，才可结束外层的当次循环，开始下一次的循环[听不懂，走案例]。
设外层循环次数为m次，内层为n次，则内层循环体实际上需要执行m*n次。

java

for( int i=1;i<=7;i++){//第一层循环7次
for( int j=1;j<=2;j++){//第二层循环2次
System.out.println("ok~~"); //7*2=14次
}
}

多重循环执行步骤分析

请分析下面的多重循环执行步骤，并写出输出=>韩老师的内存分析法

java

//双层for (MulFor.java)
for(int i = 0; i < 2; i++) { //外层循环2次
for( int j = 0; j < 3; j++) { //内层循环3次
System.out.println("i=" + i + " j=" + j);
}
}
//输出结果：
//i=0 j=0
//i=0 j=1
//i=0 j=2
//i=1 j=0
//i=1 j=1
//i=1 j=2

应用实例

(MulForExercise01.java)

统计3个班成绩情况，每个班有5名同学，求出各个班的平均分和所有班级的平均分[学生的成绩从键盘输入]。
统计三个班及格人数，每个班有5名同学。

java

import java.util.Scanner;
public class MulForExercise01 {
//编写一个main 方法
public static void main(String[] args) {
//思路分析:
//化繁为简
//(1) 先计算一个班，5个学生的成绩和平均分，使用for
//1.1 创建Scanner 对象然后，接收用户输入
//1.2 得到该班级的平均分，定义一个double sum 把该班级5个学生的成绩累积
//(2) 统计3个班(每个班5个学生) 平均分
//(3) 所有班级的平均分
//3.1

S01-05 JavaSE-基础-流程控制语句 ​

程序流程控制介绍 ​

顺序控制 ​

顺序控制举例和注意事项 ​

分支控制if-else ​

分支控制if-else 介绍 ​

单分支 ​

案例说明 ​

单分支流程图 ​

双分支 ​

基本语法 ​

案例演示 ​

双分支流程图 ​

单分支和双分支练习题 ​

多分支 ​

基本语法 ​

多分支的流程图(重要!) ​

案例演示1 ​

案例演示2 ​

嵌套分支 ​

基本介绍 ​

基本语法 ​

应用案例 ​

应用案例2，一定自己做 ​

switch 分支结构 ​

基本语法 ​

流程图 ​

快速入门 ​

switch 注意事项和细节讨论 ​

switch 课堂练习(学员先做) ​

switch 和if 的比较 ​

for 循环控制(!!!) ​

基本介绍 ​

看一个实际需求 ​

基本语法 ​

for 循环执行流程分析 ​

注意事项和细节说明 ​

for 循环练习题(学员先做) ​

while 循环控制 ​

基本语法 ​

while 循环执行流程分析 ​

注意事项和细节说明 ​

课堂练习题[学员先做] ​

do..while 循环控制 ​

基本语法 ​

老韩说明 ​

do...while 循环执行流程分析 ​

注意事项和细节说明 ​

课堂练习题【学员先做】 ​

多重循环控制(难点! 重点!) ​

介绍 ​

多重循环执行步骤分析 ​

应用实例 ​

S01-05 JavaSE-基础-流程控制语句

程序流程控制介绍

顺序控制

顺序控制举例和注意事项

分支控制if-else

分支控制if-else 介绍

单分支

案例说明

单分支流程图

双分支

基本语法

案例演示

双分支流程图

单分支和双分支练习题

多分支

基本语法

多分支的流程图(重要!)

案例演示1

案例演示2

嵌套分支

基本介绍

基本语法

应用案例

应用案例2，一定自己做

switch 分支结构

基本语法

流程图

快速入门

switch 注意事项和细节讨论

switch 课堂练习(学员先做)

switch 和if 的比较

for 循环控制(!!!)

基本介绍

看一个实际需求

基本语法

for 循环执行流程分析

注意事项和细节说明

for 循环练习题(学员先做)

while 循环控制

基本语法

while 循环执行流程分析

注意事项和细节说明

课堂练习题[学员先做]

do..while 循环控制

基本语法

老韩说明

do...while 循环执行流程分析

注意事项和细节说明

课堂练习题【学员先做】

多重循环控制(难点! 重点!)

介绍

多重循环执行步骤分析

应用实例